"""
WebSocket 服务实现 - 使用WebSocketServer
"""
import asyncio
import json
import threading
from typing import Dict, Any, Optional, List, Callable

from app.services.websocket_service import IWebSocketService
from app.services.comment_service import ICommentService
from app.services.base_service import BaseService, Event
from app.utils.logger import Logger
from app.services.websocket_server import WebSocketServer


class WebSocketService(BaseService, IWebSocketService):
    """
    WebSocket 服务实现 - 使用WebSocketServer
    """
    
    def __init__(self):
        """
        初始化 WebSocket 服务
        """
        super().__init__()
        
        # 获取日志记录器
        self.logger = Logger.get_logger("websocket_service")
        
        # 评论服务
        self._comment_service: Optional[ICommentService] = None
        
        # 创建WebSocketServer实例
        self._server = WebSocketServer(host="0.0.0.0", port=8765)
        self._server.set_message_callback(self._on_message)
        self._server.set_connection_callback(self._on_connection_changed)
        
        # 消息监听器
        self._message_listeners = []
        
        # 配置
        self._config = {}
        
        self.logger.info("WebSocket 服务初始化完成")
    
    # 以下方法是接口要求实现的，但在本项目中不使用，保留空实现
    def connect(self, url: str) -> bool:
        return False
    
    def disconnect(self) -> bool:
        return True
    
    def is_connected(self) -> bool:
        return False
    
    def send_message(self, message: Dict[str, Any]) -> bool:
        return False
    
    def convert_emoji(self, text: str) -> str:
        return text
    
    def get_connection_status(self) -> str:
        """
        获取连接状态
        
        @return: 连接状态字符串
        """
        if self._server.running:
            if self._server.clients:
                return "已连接"
            else:
                return "未连接"
        else:
            return "未连接"
    
    def configure(self, config: Dict[str, Any]) -> None:
        """
        配置 WebSocket 服务
        
        @param config: 配置字典
        """
        self._config = config
        
        # 更新服务器设置
        if "server_port" in config:
            self._server.port = config["server_port"]
        
        if "server_host" in config:
            self._server.host = config["server_host"]
        
        self.logger.debug(f"配置 WebSocket 服务: {config}")
    
    def set_comment_service(self, comment_service: ICommentService) -> None:
        """
        设置评论服务
        
        @param comment_service: 评论服务实例
        """
        self._comment_service = comment_service
        self.logger.debug("设置评论服务")
    
    def start_server(self, port: int = 8765) -> bool:
        """
        启动 WebSocket 服务器
        
        @param port: 服务器端口
        @return: 是否成功启动
        """
        if self._server.running:
            self.logger.warning("WebSocket 服务器已在运行中")
            return True
        
        try:
            # 更新端口
            self._server.port = port
            
            # 创建一个新线程来运行WebSocket服务器
            def server_thread():
                try:
                    # 创建事件循环
                    loop = asyncio.new_event_loop()
                    asyncio.set_event_loop(loop)
                    
                    # 启动服务器
                    loop.run_until_complete(self._server.start())
                    loop.run_forever()
                except Exception as e:
                    self.logger.error(f"WebSocket服务器线程错误: {str(e)}")
                    # 通知状态更改
                    self.notify("connection_status_changed", "服务器错误")
            
            # 启动线程
            self._server_thread = threading.Thread(target=server_thread, daemon=True)
            self._server_thread.start()
            
            # 等待短暂时间，以确保服务器有时间启动
            import time
            time.sleep(1.0)
            
            return self._server.running
        except Exception as e:
            self.logger.error(f"启动 WebSocket 服务器失败: {str(e)}")
            return False
    
    def stop_server(self) -> bool:
        """
        停止 WebSocket 服务器
        
        @return: 是否成功停止
        """
        if not self._server.running:
            self.logger.warning("WebSocket 服务器未运行")
            return True
        
        try:
            # 停止服务器
            self._server.stop()
            
            # 通知状态更改
            self.notify("connection_status_changed", "未连接")
            
            return True
        except Exception as e:
            self.logger.error(f"停止 WebSocket 服务器失败: {str(e)}")
            return False
    
    def is_server_running(self) -> bool:
        """
        检查服务器是否运行中
        
        @return: 服务器是否运行
        """
        return self._server.running
    
    def add_message_listener(self, listener: Callable[[Dict[str, Any]], None]) -> None:
        """
        添加消息监听器
        
        @param listener: 消息监听器函数
        """
        if listener not in self._message_listeners:
            self._message_listeners.append(listener)
            self.logger.debug("添加消息监听器")
    
    def remove_message_listener(self, listener: Callable[[Dict[str, Any]], None]) -> None:
        """
        移除消息监听器
        
        @param listener: 消息监听器函数
        """
        if listener in self._message_listeners:
            self._message_listeners.remove(listener)
            self.logger.debug("移除消息监听器")
    
    def shutdown(self) -> None:
        """
        关闭服务
        """
        self.logger.info("WebSocket 服务正在关闭...")
        
        # 停止服务器
        self.stop_server()
        
        # 清空监听器
        self.clear_listeners()
        self._message_listeners.clear()
        
        self.logger.info("WebSocket 服务已关闭")
    
    def _on_message(self, message: Dict[str, Any]) -> None:
        """
        处理接收到的消息
        
        @param message: 接收到的消息
        """
        try:
            # 记录消息
            self.logger.debug(f"收到消息: {json.dumps(message, ensure_ascii=False)[:100]}...")
            
            # 使用消息处理器处理消息
            try:
                from app.services.message_processor import MessageProcessor
                processor = MessageProcessor.get_instance()
                processor.process_message(message, "websocket")
                self.logger.debug("消息已转发给消息处理器")
            except Exception as e:
                self.logger.error(f"使用消息处理器处理消息失败: {str(e)}")
                # 如果消息处理器处理失败，回退到原有处理方式
                if self._comment_service:
                    try:
                        self._comment_service.process_message(message)
                    except Exception as e2:
                        self.logger.error(f"评论服务处理消息失败: {str(e2)}")
            
            # 通知消息监听器 (保留原有功能，确保兼容性)
            for listener in self._message_listeners:
                try:
                    listener(message)
                except Exception as e:
                    self.logger.error(f"消息监听器异常: {str(e)}")
            
            # 触发消息接收事件 (保留原有功能，确保兼容性)
            self.notify("message_received", message)
            
        except Exception as e:
            self.logger.error(f"处理消息失败: {str(e)}")
            import traceback
            self.logger.error(f"异常堆栈: {traceback.format_exc()}")
    
    def _on_connection_changed(self, connected: bool) -> None:
        """
        处理连接状态变化
        
        @param connected: 是否已连接
        """
        # 简化为只有两种状态：已连接和未连接
        status = "已连接" if connected else "未连接"
        self.notify("connection_status_changed", status)
        self.logger.info(f"WebSocket连接状态: {status}") 